/**
 * import-es.js - 数据导入Elasticsearch页面业务逻辑
 * 功能：表单联动、任务提交、进度轮询、状态处理、表单锁定控制、文件选择
 */

// ==================== 全局变量 ====================
/** 进度轮询定时器句柄 */
let progressPollingTimer = null;

/** 任务运行状态标志 */
let isTaskRunning = false;

// ==================== 页面初始化 ====================
/**
 * DOM加载完成后初始化数据源选项
 */
document.addEventListener('DOMContentLoaded', () => {
    loadDataSourceOptions();
});

// ==================== 数据源加载 ====================
/**
 * 加载数据源选项下拉框
 */
async function loadDataSourceOptions() {
    try {
        const res = await API.getDbUrlList();
        const sel = document.getElementById('dbId');
        if (!sel) return;

        // 重置下拉框
        sel.innerHTML = '<option value="">-- 请选择 --</option>';

        // 填充选项
        if (res.code === 200 && Array.isArray(res.data)) {
            res.data.forEach(item => {
                const opt = document.createElement('option');
                opt.value = item.id;
                opt.textContent = `${item.dbType} - ${item.host}:${item.port} (${item.username})`;
                sel.appendChild(opt);
            });
        }
    } catch (err) {
        console.error('加载数据源失败:', err);
        alert('加载数据源失败，请刷新页面重试');
    }
}

// ==================== 表单联动逻辑 ====================
/**
 * 根据选中的数据源ID加载数据库列表
 * （由dbId下拉框onchange触发）
 */
async function loadDbs() {
    // 获取实时选中值
    const dbId = document.getElementById('dbId')?.value;

    // 清空依赖的数据库和表
    resetSelects(['dbName', 'tableName']);

    if (!dbId) return;

    try {
        const res = await API.getDatabases({dbId: parseInt(dbId, 10)});
        populateSelect('dbName', res);
    } catch (err) {
        console.error('加载数据库失败:', err);
        alert('加载数据库失败: ' + err.message);
    }
}

/**
 * 根据数据库名加载数据表列表，并自动填充索引名
 * （由dbName下拉框onchange触发）
 */
async function loadTables() {
    // 获取实时选中值
    const dbId = document.getElementById('dbId')?.value;
    const dbName = document.getElementById('dbName')?.value;

    // 清空表选项
    resetSelect('tableName');

    if (!dbId || !dbName) return;

    try {
        const res = await API.getTables({
            dbId: parseInt(dbId, 10),
            dbName
        });
        populateSelect('tableName', res);
        fillIndex(); // 加载完表后自动填充索引名
    } catch (err) {
        console.error('加载表失败:', err);
        alert('加载表失败: ' + err.message);
    }
}

/**
 * 根据选中的表名自动生成索引名称
 * 格式：表名转小写（如 users）
 * （由tableName下拉框onchange触发）
 */
function fillIndex() {
    // 获取实时表名
    const table = document.getElementById('tableName')?.value;
    const indexInput = document.getElementById('indexName');

    if (indexInput && table) {
        // 自动填充：表名转小写作为索引名
        indexInput.value = table.toLowerCase();
    }
}

// ==================== 表单控件辅助函数 ====================
/**
 * 重置多个下拉框为初始状态（禁用+清空）
 * @param {string[]} ids - 下拉框元素ID数组
 */
function resetSelects(ids) {
    ids.forEach(id => resetSelect(id));
}

/**
 * 重置单个下拉框
 * @param {string} id - 下拉框元素ID
 */
function resetSelect(id) {
    const el = document.getElementById(id);
    if (el) {
        el.innerHTML = '<option value="">-- 请选择 --</option>';
        el.disabled = true;
    }
}

/**
 * 填充下拉框选项（根据API响应）
 * @param {string} id - 下拉框元素ID
 * @param {Object} res - API响应对象 { code, data }
 */
function populateSelect(id, res) {
    const sel = document.getElementById(id);
    if (!sel) return;

    // 重置选项
    sel.innerHTML = '<option value="">-- 请选择 --</option>';

    // 填充数据
    if (res.code === 200 && Array.isArray(res.data)) {
        res.data.forEach(item => {
            const opt = document.createElement('option');
            opt.value = item;
            opt.textContent = item;
            sel.appendChild(opt);
        });
        sel.disabled = false; // 启用下拉框
    } else {
        sel.disabled = true;
    }
}

// ==================== 表单锁定控制（防止进行中重复操作）====================
/**
 * 锁定表单所有输入控件（任务进行中时调用）
 * 禁用所有下拉框、输入框、按钮，防止用户修改数据或重复提交
 */
function lockForm() {
    isTaskRunning = true;

    // 禁用所有下拉框
    const selects = ['dbId', 'dbName', 'tableName'];
    selects.forEach(id => {
        const el = document.getElementById(id);
        if (el) el.disabled = true;
    });

    // 禁用所有输入框（包括rulePath，防止点击触发文件选择）
    const inputs = ['condition', 'indexName', 'rulePath'];
    inputs.forEach(id => {
        const el = document.getElementById(id);
        if (el) el.disabled = true;
    });

    // 禁用文件选择按钮
    const fileSelectBtn = document.getElementById('fileSelectBtn');
    if (fileSelectBtn) fileSelectBtn.disabled = true;

    // 禁用提交和重置按钮
    const submitBtn = document.getElementById('submitBtn');
    const resetBtn = document.getElementById('resetBtn');
    if (submitBtn) {
        submitBtn.disabled = true;
        submitBtn.textContent = '任务进行中...';
    }
    if (resetBtn) resetBtn.disabled = true;
}

/**
 * 解锁表单所有输入控件（任务完成或失败后调用）
 * 恢复用户操作能力
 */
function unlockForm() {
    isTaskRunning = false;

    // 恢复数据源下拉框（始终可用）
    const dbIdSelect = document.getElementById('dbId');
    if (dbIdSelect) dbIdSelect.disabled = false;

    // 恢复数据库下拉框（如果有数据源选中）
    const dbNameSelect = document.getElementById('dbName');
    if (dbNameSelect && dbNameSelect.options.length > 1) {
        dbNameSelect.disabled = false;
    }

    // 恢复数据表下拉框（如果有数据库选中）
    const tableNameSelect = document.getElementById('tableName');
    if (tableNameSelect && tableNameSelect.options.length > 1) {
        tableNameSelect.disabled = false;
    }

    // 恢复所有输入框（包括rulePath）
    const inputs = ['condition', 'indexName', 'rulePath'];
    inputs.forEach(id => {
        const el = document.getElementById(id);
        if (el) el.disabled = false;
    });

    // 恢复文件选择按钮
    const fileSelectBtn = document.getElementById('fileSelectBtn');
    if (fileSelectBtn) fileSelectBtn.disabled = false;

    // 恢复按钮
    const submitBtn = document.getElementById('submitBtn');
    const resetBtn = document.getElementById('resetBtn');
    if (submitBtn) {
        submitBtn.disabled = false;
        submitBtn.textContent = '提交导入 ES';
    }
    if (resetBtn) resetBtn.disabled = false;
}

// ==================== 文件选择功能 ====================
/**
 * 打开文件选择器弹窗
 */
function openFileSelectModal() {
    // 获取当前 rulePath 的值（用于定位）
    const rulePathInput = document.getElementById('rulePath');
    const initialPath = rulePathInput ? rulePathInput.value.trim() : '';

    // 显示文件选择器
    FileSelector.show({
        title: '选择规则文件',
        initialPath: initialPath,
        fileOnly: true,
        onSelect: (fileNode) => {
            // 选中文件后，将路径赋值给 rulePath
            if (rulePathInput) {
                rulePathInput.value = fileNode.fullPath;
            }

            // 显示成功提示
            const statusEl = document.getElementById('importStatus');
            if (statusEl) {
                showMessage(statusEl, `✅ 已选择文件: ${fileNode.name}`, 'success');

                // 3秒后自动清除提示
                setTimeout(() => {
                    clearStatus(statusEl);
                }, 3000);
            }
        }
    });
}

/**
 * 关闭文件选择器弹窗（供HTML调用）
 */
function closeFileSelectModal() {
    FileSelector.hide();
}

// ==================== 任务提交 ====================
/**
 * 提交数据导入ES任务
 * 【关键】每次提交时实时读取当前表单值，确保数据准确性
 */
async function submitImport() {
    // 如果任务正在运行，阻止重复提交
    if (isTaskRunning) {
        alert('当前有任务正在进行中，请等待完成后再提交新任务');
        return;
    }

    // 【关键】实时获取当前表单值（不依赖缓存或全局变量）
    const dbIdEl = document.getElementById('dbId');
    const dbNameEl = document.getElementById('dbName');
    const tableNameEl = document.getElementById('tableName');
    const conditionEl = document.getElementById('condition');
    const indexNameEl = document.getElementById('indexName');
    const rulePathEl = document.getElementById('rulePath');

    // 构建请求参数
    const dto = {
        dbId: dbIdEl ? parseInt(dbIdEl.value, 10) : null,
        dbName: dbNameEl ? dbNameEl.value : null,
        tableName: tableNameEl ? tableNameEl.value : null,
        condition: conditionEl ? (conditionEl.value.trim() || null) : null,
        indexName: indexNameEl ? (indexNameEl.value.trim() || null) : null,
        rulePath: rulePathEl ? (rulePathEl.value.trim() || null) : null
    };

    // 表单验证
    if (!dto.dbId || !dto.dbName || !dto.tableName) {
        alert('请完整选择数据源、数据库和数据表');
        return;
    }

    // 停止可能存在的旧轮询
    stopPolling();

    // 锁定表单，防止用户修改或重复提交
    lockForm();

    const statusEl = document.getElementById('importStatus');
    if (statusEl) {
        statusEl.textContent = '提交中...';
        statusEl.className = 'status';
    }

    try {
        const res = await API.importEs(dto);

        // 【关键修复】正确判断响应成功条件
        if (res.code === 200 && res.data) {
            const batchNo = res.data;

            // 显示成功消息
            if (statusEl) {
                showMessage(statusEl, `✅ 任务已提交，批次号: ${batchNo}`, 'success');
            }

            // 显示进度监控区域
            const progressSection = document.getElementById('progressSection');
            const batchNoDisplay = document.getElementById('batchNoDisplay');
            if (progressSection && batchNoDisplay) {
                batchNoDisplay.textContent = batchNo;
                progressSection.style.display = 'block';
            }

            // 初始化进度UI
            initializeProgressUI();

            // 延迟1秒后启动轮询（避免立即查询无数据）
            setTimeout(() => {
                pollImportProgress(batchNo);
                progressPollingTimer = setInterval(() => {
                    pollImportProgress(batchNo);
                }, 5000); // 每5秒轮询一次
            }, 1000);
        } else {
            // 提交失败：显示错误信息并解锁表单
            const msg = res.message || res.data?.message || '提交失败';
            if (statusEl) {
                showMessage(statusEl, `❌ ${msg}`, 'error');
            }
            unlockForm(); // 失败时解锁表单
        }
    } catch (err) {
        // 网络异常：解锁表单
        console.error('提交导入任务失败:', err);
        if (statusEl) {
            showMessage(statusEl, `❌ 网络错误: ${err.message}`, 'error');
        }
        unlockForm(); // 异常时解锁表单
    }
}

/**
 * 初始化进度条UI状态
 */
function initializeProgressUI() {
    const progressBar = document.getElementById('progressBar');
    const progressText = document.getElementById('progressText');
    const progressMsg = document.getElementById('progressMsg');
    const finishCountDisplay = document.getElementById('finishCountDisplay');
    const totalCountDisplay = document.getElementById('totalCountDisplay');

    if (progressBar) progressBar.style.width = '0%';
    if (progressText) progressText.textContent = '等待任务开始...';
    if (progressMsg) {
        progressMsg.textContent = '';
        progressMsg.className = 'progress-msg';
    }
    if (finishCountDisplay) finishCountDisplay.textContent = '0';
    if (totalCountDisplay) totalCountDisplay.textContent = '0';
}

// ==================== 进度轮询 ====================
/**
 * 轮询查询任务进度并更新UI
 * 支持三种状态：
 *   state=0 → 进行中
 *   state=1 → 已完成
 *   state=2 → 异常/失败
 * @param {string} batchNo - 任务批次号
 */
async function pollImportProgress(batchNo) {
    try {
        const res = await API.getImportProgress(batchNo);

        const progressBar = document.getElementById('progressBar');
        const progressText = document.getElementById('progressText');
        const progressMsg = document.getElementById('progressMsg');
        const finishCountDisplay = document.getElementById('finishCountDisplay');
        const totalCountDisplay = document.getElementById('totalCountDisplay');

        // 容错：确保DOM元素存在
        if (!progressBar || !progressText) {
            console.error('进度UI元素缺失');
            stopPolling();
            unlockForm(); // 异常时解锁
            return;
        }

        // 接口调用失败处理
        if (res.code !== 200) {
            progressText.textContent = `❌ 查询进度失败: ${res.message || '未知错误'}`;
            if (progressMsg) progressMsg.textContent = '';
            stopPolling();
            unlockForm(); // 失败时解锁
            return;
        }

        const {totalCount, finishCount, state, msg} = res.data;

        // 更新数据量对比显示
        if (finishCountDisplay) finishCountDisplay.textContent = finishCount;
        if (totalCountDisplay) totalCountDisplay.textContent = totalCount;

        // 计算进度百分比（防止除零）
        const percent = totalCount > 0
            ? Math.min(100, Math.round((finishCount / totalCount) * 100))
            : 0;

        // 更新进度条宽度
        progressBar.style.width = `${percent}%`;

        // 更新进度文本（显示百分比）
        progressText.textContent = `进度: ${percent}%`;

        // 显示后端返回的消息（如错误详情或成功提示）
        if (progressMsg) {
            progressMsg.textContent = msg || '';
            progressMsg.className = 'progress-msg';
        }

        // 根据任务状态处理不同逻辑
        if (state === 1) {
            // ✅ 任务已完成
            progressBar.style.width = '100%';
            progressText.textContent = `✅ 导入完成！(100%)`;
            if (progressMsg && !msg) {
                progressMsg.textContent = '数据已成功导入Elasticsearch';
            }
            stopPolling();
            unlockForm(); // 完成时解锁表单
        } else if (state === 2) {
            // ❌ 任务失败
            progressText.textContent = `❌ 任务失败！`;
            if (progressMsg) {
                progressMsg.textContent = msg || '未知错误，请查看后端日志';
                progressMsg.className = 'progress-msg error';
            }
            stopPolling();
            unlockForm(); // 失败时解锁表单
        }
        // state === 0：继续轮询（由setInterval控制），表单保持锁定

    } catch (err) {
        // 网络异常处理
        console.error('查询进度失败:', err);
        const textEl = document.getElementById('progressText');
        const msgEl = document.getElementById('progressMsg');

        if (textEl) textEl.textContent = `❌ 网络错误`;
        if (msgEl) {
            msgEl.textContent = err.message || '请求异常，请检查网络连接';
            msgEl.className = 'progress-msg error';
        }
        stopPolling();
        unlockForm(); // 异常时解锁表单
    }
}

/**
 * 停止进度轮询定时器
 */
function stopPolling() {
    if (progressPollingTimer) {
        clearInterval(progressPollingTimer);
        progressPollingTimer = null;
    }
}

// ==================== 表单重置 ====================
/**
 * 重置整个表单状态（清空所有输入、隐藏进度区域）
 * 只在任务未运行时允许重置
 */
function resetForm() {
    // 如果任务正在运行，阻止重置操作
    if (isTaskRunning) {
        alert('任务正在进行中，无法重置表单');
        return;
    }

    // 停止任何正在进行的轮询
    stopPolling();

    // 清空输入框
    const fields = ['dbId', 'condition', 'indexName', 'rulePath'];
    fields.forEach(id => {
        const el = document.getElementById(id);
        if (el) el.value = '';
    });

    // 重置依赖的下拉框
    resetSelects(['dbName', 'tableName']);

    // 清空状态消息
    const statusEl = document.getElementById('importStatus');
    if (statusEl) {
        statusEl.textContent = '';
        statusEl.className = '';
    }

    // 隐藏进度区域
    const progressSection = document.getElementById('progressSection');
    if (progressSection) {
        progressSection.style.display = 'none';
    }

    // 重置进度UI（为下次使用做准备）
    initializeProgressUI();

    // 确保表单解锁
    unlockForm();
}

// ==================== 工具函数：状态提示 ====================
/**
 * 显示状态消息
 * @param {HTMLElement} element - 状态元素
 * @param {string} message - 消息内容
 * @param {string} type - 消息类型：success | error
 */
function showMessage(element, message, type) {
    if (!element) return;
    element.textContent = message;
    element.className = `status ${type}`;
    element.style.display = 'inline-block';
}

/**
 * 清空状态消息
 * @param {HTMLElement} element - 状态元素
 */
function clearStatus(element) {
    if (!element) return;
    element.textContent = '';
    element.className = 'status';
    element.style.display = 'none';
}